package demo.using;

import jdk.nashorn.internal.runtime.regexp.joni.Regex;
import org.apache.commons.lang3.RandomStringUtils;
import org.apache.commons.lang3.RandomUtils;

import java.io.UnsupportedEncodingException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author : GuoFei
 * @date : 2018/10/24 11:40
 */
public class RegUsing {
    /*
    正则：
        1.匹配
            1.字符串中是否有数字、
            2.有两个连续的数字、
            3.有某个组合的数字、
            4.数字+符号+大小写字母（密码强度）
            5.6位以上
        2.切割
            1.按数字切割
        3.截取
            1.截取数字
            2.截取单词
        4.替换
            1.替换数字为：_
            2.替换字母为：*
     思路方式：
　　　　1，如果只想知道该字符是否对是错，使用匹配。
　　　　2，想要将已有的字符串变成另一个字符串，替换。
　　　　3，想要按照自定的方式将字符串变成多个字符串。切割。获取规则以外的子串。
　　　　4，想要拿到符合需求的字符串子串，获取。获取符合规则的子串。
     */

    public static void main(String[] args) {
        System.out.println("_______begin______");
//        // 1.字符串中是否有数字、
//        hasNumber();
//        // 2.有两个连续的数字、
//        hasTwoNumber();
//        // 3.有某个组合的数字、
//        hasCurrentNumber();
//        // 4.数字+符号+大小写字母（密码强度）
//        checkSecurity();
//        splitDemo();
//        getTarget();
//        replaceStr();
//        getWord();
//        justWord();
        test();
        System.out.println("________end_______");
    }

    //1.字符串中是否有数字、
    private static void hasNumber() {
        String reg = "\\d";
        String text = null;
        text = randomStr(50, true, true);
        Pattern pattern = Pattern.compile(reg);
        Matcher matcher = pattern.matcher(text);
        System.out.println(newStr("测试词：/?，包含数字：/?", text, matcher.find()));
    }

    // 4.数字+符号+大小写字母（密码强度）
    private static void checkSecurity() {
        String test = "s1@aS/";
        String numberReg = "\\d";
        String sLetterReg = "[a-z]";
        String bLetterReg = "[A-Z]";
        String otherReg = "[~!@#$%^&*()_+.]";
        int security = 0;
        boolean sLetterRegFlag = Pattern.compile(sLetterReg).matcher(test).find();
        boolean bLetterRegFlag = Pattern.compile(bLetterReg).matcher(test).find();
        boolean otherRegFlag = Pattern.compile(otherReg).matcher(test).find();
        boolean numberRegFlag = Pattern.compile(numberReg).matcher(test).find();
        if (sLetterRegFlag) {
            security++;
        }
        if (bLetterRegFlag) {
            security++;
        }
        if (otherRegFlag) {
            security++;
        }
        if (numberRegFlag) {
            security++;
        }
        if (test.length() >= 6) {
            security++;
        }
        System.out.println(newStr("" +
                "密码强度：/?/5\n" +
                "测试词是：、？,\n" +
                "大写字母：、？\n" +
                "小写字母：、？\n" +
                "数字：、？\n" +
                "特殊字符：、？\n" +
                "长度：、？/6" +
                "", test, security, bLetterRegFlag, sLetterRegFlag, numberRegFlag, otherRegFlag, test.length()));
    }

    // 2.有两个连续的数字、
    private static void hasTwoNumber() {
        String test = randomStr(20, true, true);
        String reg = "\\d{2}";
        Matcher matcher = Pattern.compile(reg).matcher(test);
        System.out.println(newStr("测试词：、？ \n拥有两个数字：、？", test, matcher.find()));
    }

    // 3.有某个组合的数字、
    private static void hasCurrentNumber() {
        String test = randomStr(20, false, true);
        String reg = "(12)";
        boolean flag = Pattern.compile(reg).matcher(test).find();
        System.out.println(newStr("测试词是：、？\n是否含有 、？ ：、？", test, reg, flag));
    }

    // 1.按数字切割
    private static void splitDemo(){
        String test = randomStr(20, true, true);
        test = test.trim();
        String reg = "\\d+";
        String[] strings = test.split(reg);
        System.out.println(newStr("测试词是：、？，\n按照数字切分",test));
        for (String s : strings) {
            System.out.println(newStr("*---*：、？",s));
        }
    }

    // 1.截取数字
    private static void getTarget(){
        String test = randomStr(20, true, true);
        String reg = "\\d+";
        Pattern pattern = Pattern.compile(reg);
        Matcher matcher = pattern.matcher(test);
        System.out.println(newStr("测试词是：、？，\n截取内部数字：",test));
        while (matcher.find()) {
            System.out.println(newStr("*---*：、？", matcher.group()));
        }
    }

    private static void getWord(){
        String test = "I am test word ni hao a zhen cong ming haha";
        String reg = "[A-z]+";
        Matcher matcher = Pattern.compile(reg).matcher(test);
        System.out.println(newStr("测试词是：、？，\n截取内部英语单词：",test));
        while (matcher.find()) {
            System.out.println(newStr("*---*:/?", matcher.group()));
        }
    }

    private static void justWord(){
        String test = randomStr(5,true,true);
        String reg = "[A-z]{" + test.length() + "}";
        boolean flag = Pattern.compile(reg).matcher(test).find();
        System.out.println(newStr("测试词是：、？\n全部是英文：、？", test, flag));
    }

    // 1.替换数字为：_
    // 2.替换字母为：*
    private static void replaceStr(){
        String test = randomStr(20, true, true);
        String reg1 = "[A-z]";
        String reg2 = "[0-9]";
        String result = test.replaceAll(reg1, "*");
        result = result.replaceAll(reg2, "_");
        System.out.println(newStr("测试词是：、？\n结果是：、？",test,result));
    }


    /**
     * String Helper /? -> 00
     *
     * @param text   原字符串
     * @param params 替换的字符
     */
    private static String newStr(String text, Object... params) {
        text = text.replaceAll("、？", "/?");
        for (Object p : params) {
            text = text.replaceFirst("/\\?", String.valueOf(p));
        }
        return text;
    }

    private static String randomStr(int count, boolean letters, boolean numbers) {
        return RandomStringUtils.random(count, letters, numbers);
    }

    public static void  test(){
        String text1 = "a\nab\nabc\nabcd\nfffffffid\nfilispki6684\nfjmkpdujdt";
//        Matcher matcher = Pattern.compile("\\S(([a-zA-Z0-9]{2})+)\\S").matcher(text1);
        String text2 = "\r\nABC\r\nASD\r\nADS\r\nASF\r\nBBC\r\nA|S\r\nA|D\r\nASDF\r\nDASF\r\n";
        String text3 = "12345\r\n" +
                "123456\r\n" +
                "1234561234561234\r\n" +
                "12345612345612345\r\n" +
                "a1234\r\n" +
                "a12345\r\n" +
                "-1234\r\n" +
                "-1\r\n" +
                "-12345\r\n" +
                "a-123\r\n" +
                "a-1234\r\n" +
                "a-1234a-1234a-12\r\n" +
                "a-1234a-1234a-1234\r\n" +
                "aaaaa\r\n" +
                "aaaaaa\r\n" +
                "-_=-_\r\n" +
                "-_=-_=";
//        Matcher matcher = Pattern.compile("\\bA[SDF][SDF]\\b").matcher(text2);

//        Matcher matcher = Pattern.compile("^[123][=]$" ).matcher(text3);
        Matcher matcher = Pattern.compile("^(?=.*[-_=])(?=.*[a-zA-Z]+)(?=.*\\d+).{6,16}$",Pattern.MULTILINE).matcher(text3);

        while (matcher.find()) {
            System.out.println(matcher.group(0));
        }
    }
}
